Défi EGC 2024¶

# Normalisation de la data frame
std_scaler = StandardScaler()
df1_normalized = std_scaler.fit_transform(external_df)
df1_normalized = pd.DataFrame(np.array(df1_normalized, dtype=np.float64), columns=external_df.columns,index=external_df.index)

# Lissage de la série temporelle
df_rolling = df1_normalized.rolling(window=7).mean()

# Création de la figure Plotly Express
fig = px.line(df_rolling,x=df_rolling.index,  y=["HashRate", "PriceUSD"],
              title="Evolution du HashRate et du prix du Bitcoin",
              labels={"value": "Valeur normalisée", "variable": "Variables", "Date": df_rolling.index.name},
              template="simple_white")

# Affichage de la figure
fig.show()

correlation_matrix = external_df.corr()
correlation_matrix

# Nom de la colonne à analyser dans le block_chain_by_actor_df
column_to_analyze = 'received'
# Appel d'une fonction déterminant le couple d'acteurs ayant le meilleur coefficient de corrélation 
max_index,max_col, max_value = compute_best_correlation_by_col(block_chain_by_actor_df,column_to_analyze)
print(f"La valeur maximale est {max_value} et elle se trouve à l'index  '{max_index}' dans la colonne '{max_col}'")

column_to_analyze = 'received'
max_index, max_col, max_value = compute_best_correlation_by_col(block_chain_by_actor_df, column_to_analyze)

def display_comparison(block_chain_by_actor_df,key1,key2,column_to_analyze,window):
    std_scaler = StandardScaler()
    # Filtrage des données pour la première identité
    df1 = block_chain_by_actor_df[block_chain_by_actor_df['identity'] == key1].copy()
    #df1 = df1.reset_index(drop=True)
    df1[column_to_analyze] = df1[column_to_analyze].rolling(window=window).mean()
    df1_normalized = std_scaler.fit_transform(df1[[column_to_analyze]])
    df1_normalized = pd.DataFrame(np.array(df1_normalized, dtype=np.float64), columns=[column_to_analyze],index=df1.index)
    # Filtrage des données pour la deuxième identité
    df2 = block_chain_by_actor_df[block_chain_by_actor_df['identity'] == key2].copy()
    #df1 = df1.reset_index(drop=True)
    df2[column_to_analyze] = df1[column_to_analyze].rolling(window=window).mean()
    df2_normalized = std_scaler.fit_transform(df2[[column_to_analyze]])
    df2_normalized = pd.DataFrame(np.array(df2_normalized, dtype=np.float64), columns=[column_to_analyze],index=df2.index)

    # Fusion des deux dataframes en un seul
    df = pd.concat([df1, df2])

    # Création de la figure Plotly Express
    fig = px.line(df, x=df.index, y=column_to_analyze, color="identity",
                title=f"Comparison of '{column_to_analyze}' between {key1} and {key2} (Normalized)",
                labels={"value": f"{column_to_analyze} (rolling mean)", "index": "date"})

    # Affichage de la figure
    fig.show()
display_comparison(block_chain_by_actor_df,max_col,max_index,column_to_analyze,10)

from scripts.best_correlation import best_correlation_df
best_corr_df = best_correlation_df(block_chain_by_actor_df,0)
best_corr_df = best_corr_df[best_corr_df['related_col'] !='PriceUSD'].sort_values('correlation_rate',ascending=False)
best_corr_df

related_cols = best_corr_df.related_col.unique()
rows,cols = (len(related_cols)+1)//2,2
counter = 0
fig = make_subplots(rows=rows, cols=cols)
height_per_row,width_per_col = 400,800
for cur_col in related_cols:
    cur_data = best_corr_df[best_corr_df['related_col'] == cur_col]['correlation_rate']
    row,col = (counter)//2 +1,counter%2+1
    fig.add_trace(
    go.Histogram(x=cur_data, histnorm='probability density', name=f'{cur_col} histogramm'),
    row=row, col=col
    )
    fig.add_trace(
        go.Scatter(x=cur_data, y=gaussian_kde(cur_data)(cur_data), mode='lines',name=''),
        row=row, col=col
    )
    counter+=1
    
fig.update_layout(height=height_per_row*rows, width=width_per_col*cols, title_text="Histogrammes")
# Afficher le graphique
fig.show()

""" best_corr_df = block_chain_by_actor_df.groupby(by='identity').sum()

def plot_rep(pivot_df: pd.DataFrame, colonne:str):
    fig = px.pie(pivot_df,values=colonne,names=pivot_df.index)
    fig.update_traces(textposition='inside')
    fig.update_layout(title_text=f'{colonne} repartition.')
    fig.show()

#plot_rep(pivot_df, 'received')
cols = 2
rows = 1
fig = make_subplots(rows=rows, cols=cols)

# Ajouter le diagramme camembert pour la colonne 'sum_fee'
fig.add_pie(go.Pie(labels=best_corr_df.index, values=best_corr_df['sum_fee'], name= 'Frais'), row=1, col=1)

# Ajouter le diagramme camembert pour la colonne 'spent'
fig.add_pie(go.Pie(labels=best_corr_df.index, values=best_corr_df['spent'], name='Dépenses'), row=1, col=2)

# Mettre à jour les options de layout
fig.update_traces(textposition='inside')
fig.update_layout(title_text='Repartition des frais et dépenses par date')
fig.show() """

grouped_df = block_chain_by_actor_df.groupby('identity')[['received']].mean()
grouped_df = grouped_df.sort_values('received',ascending=False)
fig = px.bar(grouped_df.head(10), y=['received'], barmode='group')

# Afficher le graphique
fig.show()

display_correlation_by_col(merge_df.drop("PriceUSD",axis=1),window_size=7,column_to_analyze='received')